﻿using System;
using System.Collections;
using Microsoft.VisualBasic;



namespace Bussiness.LeasingLogic
{
    #region enums
    public enum  Gyak : int
    {
        Havi = 1,
        Negyedev = 3,
        Feleves = 6,
        Eves = 12
    }

    public enum Eredmeny
    {
        THM
    }

    public enum KamatGyak : int
    {
        Havi = 1,
        Negyedev = 3
    }

   public enum OszlopFejlec
   {
    [StringValue("Hónap")] honap = 1,
    [StringValue("Tőke egyenleg")] TokeEgy = 2,
    [StringValue("Tőke törlesztés")] TokeTorl = 3,
    [StringValue("Kamat törlesztés")] KamatTorl = 4,
    [StringValue("Kezelési költség")] KezKtg = 5,
    [StringValue("Törlesztés")] Torlesztes = 6,
    [StringValue("Törlesztés devizában")] TorlesztesDeviza = 7

   }

   public enum eCID
   {
       FinanszOsszeg, //ok
       FinanszOsszegBASE, //ok
       Futamido,  //ok
       Kamat, //ok
       TokeFizGyak, //ok
       KamatfizGyak, //ok

       TurelmiIdo, //ok
       TurelmIdoKamat, //ok

       Devizanem, //ok
       Arfolyam, //ok

       KezelKtgSZ, //ok
       KezelKtgERT, //ok
       KezelKtgMin, //ok
       KezelKtgMax,//ok
       KezelKtgGyak, //ok

       FolyKtgSZ,
       FolyKtgERT,
       FolyKtgMin,
       FolyKtgMax,
       FolyjutBe,

       HitelBirSZ,
       HitelBirERT,
       HitBirBe,

       ErtekBecslSZ,
       ErtekBecslERT,
       ErtBecsBe,

       HelySzemleSZ,
       HelySzemleERT,
       HelySzemBe

   }


   public enum KalkTipus:int
   {
       egyenletesToketorlesztes = 1,
       annuitasos = 2
   }

    #endregion


   public class CalcInputData
   {
       #region FinanszirozottOsszeg

       protected double _FinanszirozottOsszeg;

       protected double _FinanszirozottOsszegBASE;

       public double FinanszirozottOsszegBASE
       {
           get
           {
               return _FinanszirozottOsszegBASE;
           }
           set
           {
               DBLRekalk("FIN", value);

           }
       }

       public double FinanszirozottOsszeg
       {
           get
           {
               return _FinanszirozottOsszeg;
           }
           set
           {
               DBLRekalk("FIN", value);

           }
       }

       #endregion

       #region Futammidő

       protected int _Futamido;

       public int Futamido
       {
           get
           {
               return _Futamido;
           }
           set
           {
               setFutamido((int)value);

           }
       }

       protected void setFutamido(int pFutamido)
       {
           _Futamido = pFutamido;
       }
       #endregion

       #region Kamat
       protected double _Kamat;
       public double Kamat
       {
           get
           {
               return _Kamat;
           }
           set
           {
               setKamat((double)value);

           }
       }

       protected void setKamat(double pKamat)
       {
           _Kamat = pKamat;
       }

       #endregion

       #region Kezelési költség
       protected double _KezKtg;
       protected Gyak _KezKtgFizGyak;
       protected double _KezelKtgERT;
       protected double _KezelKtgMin;
       protected double _KezelKtgMax;

       public Gyak KezKtgFizGyak
       {
           get
           {
               return _KezKtgFizGyak;
           }
           set
           {
               _KezKtgFizGyak=value;

           }
       }
       public double KezKtg
       {
           get
           {
               return _KezKtg;
           }
           set
           {
               _KezKtg =value;

           }
       }
       public double KezelKtgERT
       {
           get
           {
               return _KezelKtgERT;
           }
           set
           {
               _KezelKtgERT =value;

           }
       }
       public double KezelKtgMin
       {
           get
           {
               return _KezelKtgMin;
           }
           set
           {
               _KezelKtgMin = value;

           }
       }
       public double KezelKtgMax
       {
           get
           {
               return _KezelKtgMax;
           }
           set
           {
               _KezelKtgMax = value;

           }
       }

       #endregion

       #region Tőke- KezelésiKtg- és Kamatfizetés Gyakoriság

       protected Gyak _TokeFizGyak;
       protected Gyak _KamatFizGyak;


       public Gyak TokeFizGyak
       {
           get
           {
               return _TokeFizGyak;
           }
           set
           {
               setTokeFizGyak((Gyak)value);

           }
       }

       protected void setTokeFizGyak(Gyak pTokeFizGyak)
       {
           _TokeFizGyak = pTokeFizGyak;
       }

       public Gyak KamatFizGyak
       {
           get
           {
               return _KamatFizGyak;
           }
           set
           {
               setKamatFizGyak((Gyak)value);

           }
       }

       protected void setKamatFizGyak(Gyak pKamatFizGyak)
       {
           _KamatFizGyak = pKamatFizGyak;
       }


       #endregion

       #region Árfolyam
       protected double _Arfolyam;
       public double Arfolyam
       {
           get
           {
               return _Arfolyam;
           }
           set
           {
               setArfolyam(value);

           }
       }
       protected void setArfolyam(double pArfolyam)
       {
           _Arfolyam = pArfolyam;
           if (pArfolyam != 0 ) {_FinanszirozottOsszeg = _FinanszirozottOsszegBASE/pArfolyam;}

       }
       #endregion

       #region Devizanem
       protected string _Deviza;
       public string Deviza
       {
           get
           {
               return _Deviza;
           }
           set
           {
               _Deviza = value;

           }
       }
        #endregion

       #region Türelmi idő
       protected int _TurIdo;
       public int TurIdo
       {
           get
           {
               return _TurIdo;
           }
           set
           {
               _TurIdo = value;

           }
       }
       #endregion

       #region Türelmi idő kamat
       protected double _TurIdoKam;
       public double TurIdoKam
       {
           get
           {
               return _TurIdoKam;
           }
           set
           {
               _TurIdoKam = value;

           }
       }
       #endregion

       #region Folyósítási jutalék
       protected double _FolyKtgSZ;
       protected double _FolyKtgERT;
       protected double _FolyKtgMin;
       protected double _FolyKtgMax;

       public bool FolyJutBe;

       public double FolyKtgSZ
       {
           get
           {
               return _FolyKtgSZ;
           }
           set
           {
               _FolyKtgSZ = value;

           }
       }
       public double FolyKtgERT
       {
           get
           {
               return _FolyKtgERT;
           }
           set
           {
               _FolyKtgERT = value;

           }
       }
       public double FolyKtgMin
       {
           get
           {
               return _FolyKtgMin;
           }
           set
           {
               _FolyKtgMin = value;

           }
       }
       public double FolyKtgMax
       {
           get
           {
               return _FolyKtgMax;
           }
           set
           {
               _FolyKtgMax = value;

           }
       }


       #endregion

       #region Hitelbírálati díj
       protected double _HitelBirSZ;
       protected double _HitelBirERT;

       public bool HitBirBe;

       public double HitelBirSZ
       {
           get
           {
               return _HitelBirSZ;
           }
           set
           {
               DBLRekalk("HBS",value);

           }
       }
       public double HitelBirERT
       {
           get
           {
               return _HitelBirERT;
           }
           set
           {
               DBLRekalk("HBE", value); 

           }
       }
       #endregion

       #region Értékbecslési díj
       protected double _ErtekBecslSZ;
       protected double _ErtekBecslERT;

       public bool ErtBecsBe;

       public double ErtekBecslSZ
       {
           get
           {
               return _ErtekBecslSZ;
           }
           set
           {
               DBLRekalk("EBS", value); 

           }
       }
       public double ErtekBecslERT
       {
           get
           {
               return _ErtekBecslERT;
           }
           set
           {
               DBLRekalk("EBE", value); 

           }
       }
       #endregion

       #region Helyszini szemle díja
       protected double _HelySzemleSZ;
       protected double _HelySzemleERT;

       public bool HelySzemBe;

       public double HelySzemleSZ
       {
           get
           {
               return _HelySzemleSZ;
           }
           set
           {
               DBLRekalk("HSS", value);

           }
       }
       public double HelySzemleERT
       {
           get
           {
               return _HelySzemleERT;
           }
           set
           {
               DBLRekalk("HSE", value);

           }
       }
       #endregion
       
       private void DBLRekalk(string cf, double p)
       {
           double tmpFinOssz = 0;

           if (cf == "FIN") 
           {
               _FinanszirozottOsszegBASE = p;
               if (_Arfolyam > 0)
               {
                   _FinanszirozottOsszeg = p / _Arfolyam;
               }
               else
               {
                   _FinanszirozottOsszeg = p;
               }
           }
           tmpFinOssz = _FinanszirozottOsszegBASE;
           if (tmpFinOssz != 0)
           {
               switch (cf) 
               {
                   case "HBS":
                       if (p > 0)
                       {
                           _HitelBirERT = FinanszirozottOsszegBASE * p / 100;
                           _HitelBirSZ = p;
                       }
                       break;
                   case "HBE":
                       {
                           _HitelBirERT = p;
                           HitelBirSZ = _HitelBirSZ;
                           break;
                       }
                   case "HSS":
                       if (p > 0)
                       {
                           _HelySzemleERT = FinanszirozottOsszegBASE * p / 100;
                           _HelySzemleSZ = p;
                       }
                       break;
                   case "HSE":
                       {
                           _HelySzemleERT = p;
                           HelySzemleSZ = _HelySzemleSZ;
                           break;
                       }
                   case "EBS":
                       if (p > 0)
                       {
                           _ErtekBecslERT = FinanszirozottOsszegBASE * p / 100;
                           _ErtekBecslSZ = p;
                       }
                       break;
                   case "EBE":
                       {
                           _ErtekBecslERT = p;
                           ErtekBecslSZ = _ErtekBecslSZ;
                           break;
                       }
               }
           }
       }
       #region Contructor...

       public  CalcInputData()
       {
       }

       #endregion

   }

    public class CalcOutputData
    {
        public double THM
        {
            get
            {
                double tmpT = 0;
                CalcOutputRow tmpOutputRow;
                Double[] iVA;
                ArrayList irrArrayList = new ArrayList();
                irrArrayList.Add((Double)cc.InputParams.FinanszirozottOsszeg * -1);
                for (int i = 1; i < _Eredmeny.Count; i++)
                {
                    
                   tmpOutputRow = (CalcOutputRow)cc.COD.Eredmeny[i];
                   irrArrayList.Add((Double)tmpOutputRow.getDblTorlesztes());
                   //tmpT += tmpOutputRow.getDblTorlesztes();                 
                }

                iVA = (Double[])irrArrayList.ToArray(typeof(Double));
                return Math.Round((Math.Pow(Microsoft.VisualBasic.Financial.IRR(ref iVA, 0.001)+1, 12) - 1) * 100, 2);
                

            }
        }

        private ArrayList _Eredmeny;

        public ArrayList Eredmeny
        {
            get
            {
                return _Eredmeny;
            }
            set
            {
                _Eredmeny = value;
            }

        }

        private ArrayList _Fejlec;

        public ArrayList Fejlec
        {
            get
            {
                return _Fejlec;
            }
            set
            {
                _Fejlec = value;
            }

        }

        public CalcOutputData()
        {
            _Eredmeny = new ArrayList();
            _Fejlec = new ArrayList();
        }

        public Calculation cc;

    }

    public class Calculation
    {
        //Input parameters.
        #region Kalkuláció bemeneti paraméterei
        protected CalcInputData _InputParams;
        public CalcInputData InputParams
        {
            get
            {
                return _InputParams;
            }
            set
            {
                setInputParams((CalcInputData)value);

            }
        }

        protected void setInputParams(CalcInputData pInputParams)
        {
            _InputParams = pInputParams;
        }

        #endregion

        #region Kalkuláció típusa

        protected int _KalkTipus;
        public int KalkTipus
        {
            get
            {
                return _KalkTipus;
            }
            set
            {
                setKalkTipus((int)value);

            }
        }

        protected void setKalkTipus(int pKalkTipus)
        {
            _KalkTipus = pKalkTipus;
        }

        #endregion


        // gets input parameter data from CalcInputData
        #region Paraméterbetöltés

        private string getStrParams(eCID pName)
        {
            string ret = "";
            switch (pName)
            {
                case eCID.Devizanem: ret = _InputParams.Deviza; break;


            }

            return ret;
        }
        private int getIntParams(eCID pName)
        {
            int ret = 0;
            switch (pName)
            {
                case eCID.Futamido: ret = _InputParams.Futamido; break;
                case eCID.TurelmiIdo: ret = _InputParams.TurIdo; break;
            
            }
            
            return ret;
        }

        private bool getBoolParams(eCID pName)
        {
            bool ret = false;
            switch (pName)
            {
                case eCID.FolyjutBe: ret = _InputParams.FolyJutBe; break;
                case eCID.ErtBecsBe: ret = _InputParams.ErtBecsBe; break;
                case eCID.HelySzemBe: ret = _InputParams.HelySzemBe; break;
                case eCID.HitBirBe: ret = _InputParams.HitBirBe; break;

            }

            return ret;
        }
        private double getDblParams(eCID pName)
        {
            double ret = 0;
            switch (pName)
            {
                case eCID.FinanszOsszeg: ret = _InputParams.FinanszirozottOsszeg; break;
                case eCID.FinanszOsszegBASE: ret = _InputParams.FinanszirozottOsszegBASE; break;
                case eCID.Kamat: ret = _InputParams.Kamat; break;
                case eCID.KezelKtgSZ: ret = _InputParams.KezKtg; break;
                case eCID.KezelKtgERT: ret = _InputParams.KezelKtgERT; break;
                case eCID.KezelKtgMax: ret = _InputParams.KezelKtgMax; break;
                case eCID.KezelKtgMin: ret = _InputParams.KezelKtgMin; break;
                case eCID.TurelmIdoKamat: ret = _InputParams.TurIdoKam; break;
                case eCID.FolyKtgSZ: ret = _InputParams.FolyKtgSZ; break;
                case eCID.FolyKtgERT: ret = _InputParams.FolyKtgERT; break;
                case eCID.FolyKtgMin: ret = _InputParams.FolyKtgMin; break;
                case eCID.FolyKtgMax: ret = _InputParams.FolyKtgMax; break;
                case eCID.HitelBirSZ: ret = _InputParams.HitelBirSZ; break;
                case eCID.HitelBirERT: ret = _InputParams.HitelBirERT; break;
                case eCID.ErtekBecslSZ: ret = _InputParams.ErtekBecslSZ; break;
                case eCID.ErtekBecslERT: ret = _InputParams.ErtekBecslERT; break;
                case eCID.HelySzemleSZ: ret = _InputParams.HelySzemleSZ; break;
                case eCID.HelySzemleERT: ret = _InputParams.HelySzemleERT; break;

            }
            return ret;
        }

        private Gyak getGyakParams(eCID pName)
        {
            Gyak ret = Gyak.Havi;

            switch (pName)
            {
                case eCID.TokeFizGyak: ret = _InputParams.TokeFizGyak; break;
                case eCID.KezelKtgGyak: ret = _InputParams.KezKtgFizGyak; break;
                case eCID.KamatfizGyak: ret = _InputParams.KamatFizGyak; break;

            }

            return ret;
        }

        #endregion


        //Output parameters.
        #region Eredmeny

        public CalcOutputData COD
        {
            get
            {
                return _cod;
            }
        }

        protected CalcOutputData _cod;

        internal void AdderedmenySor(CalcOutputRow pEredmenySor)
        {
            CalcOutputRow newSor = pEredmenySor;
            _cod.Eredmeny.Add(newSor);

        }

        public String GetEredmenySTR(int l)
        {
            CalcOutputRow tmpOutputRow;
            tmpOutputRow = (CalcOutputRow)_cod.Eredmeny[l];

            return tmpOutputRow.ResultString;
        }

        public CalcOutputRow GetEredmeny(int l)
        {
            CalcOutputRow tmpOutputRow;
            tmpOutputRow = (CalcOutputRow)_cod.Eredmeny[l];

            return tmpOutputRow;
        }

        // Fejléc visszaadása

        internal void AddFejlec(CalcHeader pFejlec)
        {
            CalcHeader newSor = pFejlec;
            _cod.Fejlec.Add(newSor);

        }

        public CalcHeader GetFejlecSor(int l)
        {
            CalcHeader tmpFejlecSor;
            tmpFejlecSor = (CalcHeader)_cod.Fejlec[l];

            return tmpFejlecSor;
        }

        #endregion

        

        #region Constructor;

        public Calculation(int pKalkTipus)
        {
            _KalkTipus = pKalkTipus;
            _InputParams = new CalcInputData();
            _cod = new CalcOutputData();
            _cod.cc = this;

        }

        public Calculation(int pKalkTipus,
                CalcInputData pInputParameters
                ) 
        {
            _KalkTipus = pKalkTipus;
            _InputParams = pInputParameters;
            _cod = new CalcOutputData();
            _cod.cc = this;
        }

        #endregion


        #region Kalkuláció
        public bool KalkEredmeny()
        {
            bool ret = false;
            KalkFejlec();

            switch (_KalkTipus)
            {
                case 1: //Egyenletes tőketörlesztés
                    KalkEredmenyEgyTokeTorl();
                    ret = true;
                    break;

                case 2: //Annuitásos
                    KalkAnnuitasosTorl();
                    ret = true;
                    break;

                default:
                    ret = false;
                    break;
            }
            return ret;
        }

        protected void KalkFejlec()
        {
            _cod.Fejlec.Clear();


            /// folyósítási jutalék.

            double foly_jut = 0;
            double hitelbir = 0;
            double ertekbecsl = 0;
            double helyszini_szeml = 0;

            if (!(getBoolParams(eCID.FolyjutBe)) && ((getDblParams(eCID.FolyKtgERT) > 0) || (getDblParams(eCID.FolyKtgSZ) > 0)))
            {
                if (getDblParams(eCID.FolyKtgSZ) > 0) 
                {
                    foly_jut = Math.Min(getDblParams(eCID.FolyKtgMax),Math.Max((getDblParams(eCID.FinanszOsszegBASE) * getDblParams(eCID.FolyKtgSZ) * 0.01),getDblParams(eCID.FolyKtgMin)));
                }
                if ((foly_jut == 0) && (getDblParams(eCID.FolyKtgERT) > 0))
                {
                    foly_jut = getDblParams(eCID.FolyKtgERT);
                }

            }
            if (foly_jut != 0) { AddFejlec(new CalcHeader("Folyósítási jutalék", foly_jut, false)); }
            
            /// hitelbirálati díj
            if (!(getBoolParams(eCID.HitBirBe)) && ((getDblParams(eCID.HitelBirERT) > 0) || (getDblParams(eCID.HitelBirSZ) > 0)))
            {
                if (getDblParams(eCID.HitelBirSZ) > 0)
                {
                    hitelbir = (getDblParams(eCID.FinanszOsszegBASE) * getDblParams(eCID.HitelBirSZ) * 0.01);
                }
                if ((hitelbir == 0) && (getDblParams(eCID.HitelBirERT) > 0))
                {
                    hitelbir = getDblParams(eCID.HitelBirERT);
                }

            }
            if (hitelbir != 0) { AddFejlec(new CalcHeader("Hitelbírálati díj", hitelbir, false)); }

            /// Értékbecslési díj
            if (!(getBoolParams(eCID.ErtBecsBe)) && ((getDblParams(eCID.ErtekBecslSZ) > 0) || (getDblParams(eCID.ErtekBecslERT) > 0)))
            {
                if (getDblParams(eCID.ErtekBecslSZ) > 0)
                {
                    ertekbecsl = (getDblParams(eCID.FinanszOsszegBASE) * getDblParams(eCID.ErtekBecslSZ) * 0.01);
                }
                if ((ertekbecsl == 0) && (getDblParams(eCID.ErtekBecslERT) > 0))
                {
                    ertekbecsl = getDblParams(eCID.ErtekBecslERT);
                }

            }
            if (ertekbecsl != 0) { AddFejlec(new CalcHeader("Értékbecslési díj", ertekbecsl, false)); }

            /// Helyszini szemle díja
            if (!(getBoolParams(eCID.HelySzemBe)) && ((getDblParams(eCID.HelySzemleSZ) > 0) || (getDblParams(eCID.HelySzemleERT) > 0)))
            {
                if (getDblParams(eCID.HelySzemleSZ) > 0)
                {
                    helyszini_szeml = (getDblParams(eCID.FinanszOsszegBASE) * getDblParams(eCID.HelySzemleSZ) * 0.01);
                }
                if ((helyszini_szeml == 0) && (getDblParams(eCID.HelySzemleERT) > 0))
                {
                    helyszini_szeml = getDblParams(eCID.HelySzemleERT);
                }

            }
            if (helyszini_szeml != 0) { AddFejlec(new CalcHeader("Helyszini szemle díja", helyszini_szeml, false)); }

            //Összegzés

            if (_cod.Fejlec.Count>0) 
            {
                double sum = 0;
                for (int i = 0; i < _cod.Fejlec.Count; i++)
                {
                    sum += GetFejlecSor(i).KoltsegOsszeg; 
                }
                if (sum != 0) { AddFejlec(new CalcHeader("Szerződéskötéskor fizetendő", sum, true)); }
            }


        }


        #endregion
        #region Annuitásos kalkuláció

        protected void KalkAnnuitasosTorl()
        {
            _cod.Eredmeny.Clear();
            double iTokeEgyenleg = Math.Round(getDblParams(eCID.FinanszOsszeg), 2);
            double iTokeEgyenleg2 = Math.Round(getDblParams(eCID.FinanszOsszeg), 2);
            if (getBoolParams(eCID.HelySzemBe)) { iTokeEgyenleg2 += Math.Round(getDblParams(eCID.HelySzemleERT), 2); }
            if (getBoolParams(eCID.FolyjutBe)) { iTokeEgyenleg2 += Math.Round(getDblParams(eCID.FolyKtgERT), 2); }
            if (getBoolParams(eCID.HitBirBe)) { iTokeEgyenleg2 += Math.Round(getDblParams(eCID.HitelBirERT), 2); }
            if (getBoolParams(eCID.ErtBecsBe)) { iTokeEgyenleg2 += Math.Round(getDblParams(eCID.ErtekBecslERT), 2); }

            double iTokeTorelsztes = 0;
            double iKamatTorlesztes = 0;
            double iKezelesiKtg = 0;
            double iHdij = 0;
            // Első Nullás sor felvitele.
            AdderedmenySor(new CalcOutputRow(this, 0, 0, iTokeEgyenleg2, iTokeTorelsztes, iKamatTorlesztes, 0, 0));

            iHdij = KalkAnnuitHaviDij(iTokeEgyenleg2, ((getDblParams(eCID.Kamat) / 12) * 0.01), getIntParams(eCID.Futamido));

            for (int l = 1; l <= getIntParams(eCID.Futamido); l++)
            {
                
                //if ((iTokeEgyenleg - iTokeTorelsztes < 0)) { iTokeEgyenleg = 0; }
                //else { iTokeEgyenleg -= Math.Round(iTokeTorelsztes, 2); }


                iKamatTorlesztes = KalkKamatTorlesztes(iTokeEgyenleg2, l);

                iTokeTorelsztes = iHdij - iKamatTorlesztes;
                iKezelesiKtg = KalkKezKtgTorlesztes(iTokeEgyenleg2, l);
                iTokeEgyenleg2 -= iTokeTorelsztes;
                AdderedmenySor(new CalcOutputRow(this, l, l, iTokeEgyenleg2, iTokeTorelsztes, iKamatTorlesztes, iKezelesiKtg, iHdij + iKezelesiKtg));

            }
        }

        private double KalkAnnuitHaviDij(double pHitelOssz, double pKamatSZ, int pFutamido)
        {
            //h / (1/k - 1/k/(k+1)^n)
            //return pHitelOssz * (Math.Pow((1 + pKamatSZ), pFutamido) * pKamatSZ) / (Math.Pow((1 + pKamatSZ), pFutamido) - 1);
            return pHitelOssz / ((1 / pKamatSZ) - (1 / pKamatSZ) / Math.Pow((1 + pKamatSZ), pFutamido));

        }

        #endregion

        #region Egyenletes tőketörlesztés kalkuláció

        protected void KalkEredmenyEgyTokeTorl()
        {
            //fejléc feltöltése megtörténik egy másik függvényben

            
            //eredmény feltöltése
            //Kiürítés az új kalkuláció előtt
            _cod.Eredmeny.Clear();
            double iTokeEgyenleg = Math.Round(getDblParams(eCID.FinanszOsszeg), 2);
            if (getBoolParams(eCID.HelySzemBe)) {iTokeEgyenleg += Math.Round(getDblParams(eCID.HelySzemleERT), 2);}
            if (getBoolParams(eCID.FolyjutBe)) { iTokeEgyenleg += Math.Round(getDblParams(eCID.FolyKtgERT), 2); }
            if (getBoolParams(eCID.HitBirBe)) { iTokeEgyenleg += Math.Round(getDblParams(eCID.HitelBirERT), 2); }
            if (getBoolParams(eCID.ErtBecsBe)) { iTokeEgyenleg += Math.Round(getDblParams(eCID.ErtekBecslERT), 2); }

            double iTokeTorelsztes = 0;
            double iKamatTorlesztes = 0;
            double iKezelesiKtg = 0;
            // Első Nullás sor felvitele.
            AdderedmenySor(new CalcOutputRow(this, 0, 0, iTokeEgyenleg, iTokeTorelsztes, iKamatTorlesztes, 0, 0));




            for (int l = 1; l <= getIntParams(eCID.Futamido); l++)
            {
                iTokeTorelsztes = KalkTokeTorlesztes(getDblParams(eCID.FinanszOsszeg), l, getIntParams(eCID.Futamido));
                if ((iTokeEgyenleg - iTokeTorelsztes < 0)) { iTokeEgyenleg = 0;  }
                else { iTokeEgyenleg -= Math.Round(iTokeTorelsztes, 2); }

                iKamatTorlesztes = KalkKamatTorlesztes(iTokeEgyenleg, l );

                iKezelesiKtg = KalkKezKtgTorlesztes(iTokeEgyenleg, l);
                AdderedmenySor(new CalcOutputRow(this, l, l, iTokeEgyenleg, iTokeTorelsztes, iKamatTorlesztes, iKezelesiKtg, iTokeTorelsztes + iKamatTorlesztes + iKezelesiKtg));
                
            }

        }
        private Double KalkTokeTorlesztes(double pHitelosszeg, int pAktEsed, int pTotalFutamido)
        {
            double aktTokeTorl = 0;

            switch (getGyakParams(eCID.TokeFizGyak))
            {
                case Gyak.Havi:
                    aktTokeTorl = pHitelosszeg / pTotalFutamido;
                    break;
                case Gyak.Negyedev:
                    if ((pAktEsed % 3) == 0) {
                        aktTokeTorl = (pHitelosszeg / pTotalFutamido) *3; 
                    }
                    else {
                        aktTokeTorl = 0;
                    }
                    break;
                case Gyak.Feleves:
                    if ((pAktEsed % 6) == 0)
                    {
                        aktTokeTorl = (pHitelosszeg / pTotalFutamido) * 6;
                    }
                    else
                    {
                        aktTokeTorl = 0;
                    }
                    break;
                case Gyak.Eves:
                    if ((pAktEsed % 12) == 0)
                    {
                        aktTokeTorl = (pHitelosszeg / pTotalFutamido) * 12;
                    }
                    else
                    {
                        aktTokeTorl = 0;
                    }
                    break;
                default: 
                    aktTokeTorl = 0;
                    break;
            }

            return  Math.Round(aktTokeTorl,2);
        }
        private Double KalkKamatTorlesztes(double pTokeEgy, int pAktEsed )
        {
            double aktKamatTorl = 0;

            switch (getGyakParams(eCID.KamatfizGyak))
            {
                case Gyak.Havi:
                    aktKamatTorl = (GetEredmeny(pAktEsed - 1).getDblTokeEgyenleg() * (getDblParams(eCID.Kamat) * 0.01)) / 12;
                    break;
                case Gyak.Negyedev:
                    if ((pAktEsed % 3) == 0) {
                        if (pAktEsed - 3 >= 0) 
                        {
                            aktKamatTorl = (GetEredmeny(pAktEsed - 3).getDblTokeEgyenleg() * (getDblParams(eCID.Kamat) * 0.01)) / 12;
                            aktKamatTorl += (GetEredmeny(pAktEsed - 2).getDblTokeEgyenleg() * (getDblParams(eCID.Kamat) * 0.01)) / 12;
                            aktKamatTorl += (GetEredmeny(pAktEsed - 1).getDblTokeEgyenleg() * (getDblParams(eCID.Kamat) * 0.01)) / 12;
                        }
                        else 
                        {
                            aktKamatTorl = -1;
                        }
                        
                    }
                    else {
                        aktKamatTorl = 0;
                    }
                    break;
                case Gyak.Feleves:
                    if ((pAktEsed % 6) == 0)
                    {
                        aktKamatTorl = (pTokeEgy * getDblParams(eCID.Kamat)) / 12;
                    }
                    else
                    {
                        aktKamatTorl = 0;
                    }
                    break;
                case Gyak.Eves:
                    if ((pAktEsed % 12) == 0)
                    {
                        aktKamatTorl = (pTokeEgy * getDblParams(eCID.Kamat)) / 12;
                    }
                    else
                    {
                        aktKamatTorl = 0;
                    }
                    break;
                default: 
                    aktKamatTorl = 0;
                    break;
            }

            return  Math.Round(aktKamatTorl,2);
        }
        private Double KalkKezKtgTorlesztes(double pTokeEgy, int pAktEsed )
        {
            double aktKezKtgTorl = 0;

            switch (getGyakParams(eCID.KezelKtgGyak))
            {
                case Gyak.Havi:
                    if ((pAktEsed % 12) == 1)
                    {
                        aktKezKtgTorl = (GetEredmeny(pAktEsed - 1).getDblTokeEgyenleg() * (getDblParams(eCID.KezelKtgSZ) * 0.01)) / 12;
                    }
                    else 
                    { 
                        aktKezKtgTorl = (GetEredmeny(Math.Max((pAktEsed - 1), 1)).getDblKezKtg()); 
                    }
                    break;
                case Gyak.Negyedev:
                    if ((pAktEsed % 3) == 0)
                    {
                        if (pAktEsed - 3 >= 0)
                        {
                            aktKezKtgTorl = (GetEredmeny(pAktEsed - 3).getDblTokeEgyenleg() * (getDblParams(eCID.KezelKtgSZ) * 0.01)) / 12;
                            aktKezKtgTorl += (GetEredmeny(pAktEsed - 2).getDblTokeEgyenleg() * (getDblParams(eCID.KezelKtgSZ) * 0.01)) / 12;
                            aktKezKtgTorl += (GetEredmeny(pAktEsed - 1).getDblTokeEgyenleg() * (getDblParams(eCID.KezelKtgSZ) * 0.01)) / 12;
                        }
                        else
                        {
                            aktKezKtgTorl = -1;
                        }

                    }
                    else
                    {
                        aktKezKtgTorl = 0;
                    }
                    break;
                case Gyak.Feleves:
                    if ((pAktEsed % 6) == 0)
                    {
                        if (pAktEsed - 6 >= 0)
                        {
                            aktKezKtgTorl = (GetEredmeny(pAktEsed - 6).getDblTokeEgyenleg() * (getDblParams(eCID.KezelKtgSZ) * 0.01)) / 12;
                            aktKezKtgTorl += (GetEredmeny(pAktEsed - 5).getDblTokeEgyenleg() * (getDblParams(eCID.KezelKtgSZ) * 0.01)) / 12;
                            aktKezKtgTorl += (GetEredmeny(pAktEsed - 4).getDblTokeEgyenleg() * (getDblParams(eCID.KezelKtgSZ) * 0.01)) / 12;
                            aktKezKtgTorl += (GetEredmeny(pAktEsed - 3).getDblTokeEgyenleg() * (getDblParams(eCID.KezelKtgSZ) * 0.01)) / 12;
                            aktKezKtgTorl += (GetEredmeny(pAktEsed - 2).getDblTokeEgyenleg() * (getDblParams(eCID.KezelKtgSZ) * 0.01)) / 12;
                            aktKezKtgTorl += (GetEredmeny(pAktEsed - 1).getDblTokeEgyenleg() * (getDblParams(eCID.KezelKtgSZ) * 0.01)) / 12;
                        }
                        else
                        {
                            aktKezKtgTorl = -1;
                        }
                    }
                    else
                    {
                        aktKezKtgTorl = 0;
                    }
                    break;
                case Gyak.Eves:
                    if ((pAktEsed % 12) == 0)
                    {
                        aktKezKtgTorl = (pTokeEgy * getDblParams(eCID.KezelKtgSZ)) / 12;
                    }
                    else
                    {
                        aktKezKtgTorl = 0;
                    }
                    break;
                default:
                    aktKezKtgTorl = 0;
                    break;
            }

            return Math.Round(aktKezKtgTorl, 2);
        }        
        
        
        #endregion






    }

}
